#pragma once
#include "gp_Pnt2d.h"
#include "gp_Dir2d.h"
#include "gp_Ax2d.h"

class gp_Pnt2d;
class gp_Dir2d;
class gp_Ax2d;
class gp_Trsf2d;
class gp_Vec2d;

//!  Describes a coordinate system in a plane (2D space). <br>
//! A coordinate system is defined by: <br>
//! -   its origin (also referred to as its "Location point"), and <br>
//! -   two orthogonal unit vectors, respectively, called the "X <br>
//!   Direction" and the "Y Direction". <br>
//!   A gp_Ax22d may be right-handed ("direct sense") or <br>
//! left-handed ("inverse" or "indirect sense"). <br>
//! You use a gp_Ax22d to: <br>
//! - describe 2D geometric entities, in particular to position <br>
//!   them. The local coordinate system of a geometric <br>
//!   entity serves for the same purpose as the STEP <br>
//!   function "axis placement two axes", or <br>
//! -   define geometric transformations. <br>
//! Note: we refer to the "X Axis" and "Y Axis" as the axes having: <br>
//! -   the origin of the coordinate system as their origin, and <br>
//! -   the unit vectors "X Direction" and "Y Direction", <br>
//!   respectively, as their unit vectors. <br>
class gp_Ax22d  {

public:

  

  //! Creates an object representing the reference <br>
//!            co-ordinate system (OXY). <br>
      gp_Ax22d();
  
//!  Creates a coordinate system with origin P and where: <br>
//!   -   Vx is the "X Direction", and <br>
//!   -   the "Y Direction" is orthogonal to Vx and <br>
//!    oriented so that the cross products Vx^"Y <br>
//!    Direction" and Vx^Vy have the same sign. <br>
//! Raises ConstructionError if Vx and Vy are parallel (same or opposite orientation). <br>
      gp_Ax22d(const gp_Pnt2d& P,const gp_Dir2d& Vx,const gp_Dir2d& Vy);
  
//!  Creates -   a coordinate system with origin P and "X Direction" <br>
//!   V, which is: <br>
//!   -   right-handed if Sense is true (default value), or <br>
//!   -   left-handed if Sense is false <br>
      gp_Ax22d(const gp_Pnt2d& P,const gp_Dir2d& V,const bool Sense = true);
  
//!  Creates -   a coordinate system where its origin is the origin of <br>
//!   A and its "X Direction" is the unit vector of A, which   is: <br>
//!   -   right-handed if Sense is true (default value), or <br>
//!   -   left-handed if Sense is false. <br>
      gp_Ax22d(const gp_Ax2d& A,const bool Sense = true);
  
//!  Assigns the origin and the two unit vectors of the <br>
//! coordinate system A1 to this coordinate system. <br>
        void SetAxis(const gp_Ax22d& A1) ;
  
//!  Changes the XAxis and YAxis ("Location" point and "Direction") <br>
//!  of <me>. <br>
//!  The "YDirection" is recomputed in the same sense as before. <br>
        void SetXAxis(const gp_Ax2d& A1) ;
  //! Changes the XAxis and YAxis ("Location" point and "Direction") of <me>. <br>
//!  The "XDirection" is recomputed in the same sense as before. <br>
        void SetYAxis(const gp_Ax2d& A1) ;
  
//!  Changes the "Location" point (origin) of <me>. <br>
        void SetLocation(const gp_Pnt2d& P) ;
  
//! Assigns Vx to the "X Direction"  of <br>
//! this coordinate system. The other unit vector of this <br>
//! coordinate system is recomputed, normal to Vx , <br>
//! without modifying the orientation (right-handed or <br>
//! left-handed) of this coordinate system. <br>
        void SetXDirection(const gp_Dir2d& Vx) ;
  //! Assignsr Vy to the  "Y Direction" of <br>
//! this coordinate system. The other unit vector of this <br>
//! coordinate system is recomputed, normal to Vy, <br>
//! without modifying the orientation (right-handed or <br>
//! left-handed) of this coordinate system. <br>
        void SetYDirection(const gp_Dir2d& Vy) ;
  //! Returns an axis, for which <br>
//! -   the origin is that of this coordinate system, and <br>
//! -   the unit vector is either the "X Direction"  of this coordinate system. <br>
//! Note: the result is the "X Axis" of this coordinate system. <br>
        gp_Ax2d XAxis() const;
  //! Returns an axis, for which <br>
//!    -   the origin is that of this coordinate system, and <br>
//! - the unit vector is either the  "Y Direction" of this coordinate system. <br>
//! Note: the result is the "Y Axis" of this coordinate system. <br>
        gp_Ax2d YAxis() const;
  
//!  Returns the "Location" point (origin) of <me>. <br>
       const gp_Pnt2d& Location() const;
  
//!  Returns the "XDirection" of <me>. <br>
       const gp_Dir2d& XDirection() const;
  
//!  Returns the "YDirection" of <me>. <br>
       const gp_Dir2d& YDirection() const;
  
       void Mirror(const gp_Pnt2d& P) ;
  
//!  Performs the symmetrical transformation of an axis <br>
//!  placement with respect to the point P which is the <br>
//!  center of the symmetry. <br>
//! Warnings : <br>
//!  The main direction of the axis placement is not changed. <br>
//!  The "XDirection" and the "YDirection" are reversed. <br>
//!  So the axis placement stay right handed. <br>
       gp_Ax22d Mirrored(const gp_Pnt2d& P) const;
  
       void Mirror(const gp_Ax2d& A) ;
  
//!  Performs the symmetrical transformation of an axis <br>
//!  placement with respect to an axis placement which <br>
//!  is the axis of the symmetry. <br>
//!  The transformation is performed on the "Location" <br>
//!  point, on the "XDirection" and "YDirection". <br>
//!  The resulting main "Direction" is the cross product between <br>
//!  the "XDirection" and the "YDirection" after transformation. <br>
       gp_Ax22d Mirrored(const gp_Ax2d& A) const;
  
        void Rotate(const gp_Pnt2d& P,const double Ang) ;
  
//!  Rotates an axis placement. <A1> is the axis of the <br>
//!  rotation . Ang is the angular value of the rotation <br>
//!  in radians. <br>
        gp_Ax22d Rotated(const gp_Pnt2d& P,const double Ang) const;
  
        void Scale(const gp_Pnt2d& P,const double S) ;
  
//!  Applies a scaling transformation on the axis placement. <br>
//!  The "Location" point of the axisplacement is modified. <br>
//! Warnings : <br>
//!  If the scale <S> is negative : <br>
//!   . the main direction of the axis placement is not changed. <br>
//!   . The "XDirection" and the "YDirection" are reversed. <br>
//!  So the axis placement stay right handed. <br>
        gp_Ax22d Scaled(const gp_Pnt2d& P,const double S) const;
  
        void Transform(const gp_Trsf2d& T) ;
  
//!  Transforms an axis placement with a Trsf. <br>
//!  The "Location" point, the "XDirection" and the <br>
//!  "YDirection" are transformed with T.  The resulting <br>
//!  main "Direction" of <me> is the cross product between <br>
//!  the "XDirection" and the "YDirection" after transformation. <br>
        gp_Ax22d Transformed(const gp_Trsf2d& T) const;
  
        void Translate(const gp_Vec2d& V) ;
  
//!  Translates an axis plaxement in the direction of the vector <br>
//!  <V>. The magnitude of the translation is the vector's magnitude. <br>
        gp_Ax22d Translated(const gp_Vec2d& V) const;
  
        void Translate(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;
  
//!  Translates an axis placement from the point <P1> to the <br>
//!  point <P2>. <br>
        gp_Ax22d Translated(const gp_Pnt2d& P1,const gp_Pnt2d& P2) const;
    const gp_Pnt2d& _CSFDB_Getgp_Ax22dpoint() const { return point; }
    const gp_Dir2d& _CSFDB_Getgp_Ax22dvydir() const { return vydir; }
    const gp_Dir2d& _CSFDB_Getgp_Ax22dvxdir() const { return vxdir; }



protected:




private: 


gp_Pnt2d point;
gp_Dir2d vydir;
gp_Dir2d vxdir;


};

